home *** CD-ROM | disk | FTP | other *** search
/ A.C.E. 2 / ACE CD 2.iso / FILES / UTILS / GAMESDS3.DMS / GAMESDS3.adf / GDS_Examples.lha / Examples / complex / elves.c < prev    next >
C/C++ Source or Header  |  1994-11-14  |  10KB  |  346 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <fcntl.h>
  4. #include <string.h>
  5.  
  6. #include <exec/memory.h>
  7. #include <exec/types.h>
  8. #include <graphics/gfxbase.h>
  9.  
  10. #include <clib/exec_protos.h>
  11. #include <clib/graphics_protos.h>
  12.  
  13. #include "GameSmith:include/libraries/libraries.h"
  14. #include "GameSmith:include/libraries/libptrs.h"
  15. #include "GameSmith:GameSmith.h"
  16.  
  17. #include "elf.h"
  18.  
  19. /*-------------------------------------------------------------------------*/
  20. /* Function Prototypes                                                      */
  21.  
  22. void parser(int,char **);
  23. int setup(void);
  24. void move_image(void);
  25. void check_bounds(void);
  26. int check_close(void);
  27. void cleanup(void);
  28. void free_arrays(void);
  29.  
  30. /*-------------------------------------------------------------------------*/
  31.  
  32. int elf_cnt,swidth=320,sheight=200,smode=0;
  33. int *x=NULL,*y=NULL,*speedx=NULL,*speedy=NULL;
  34. int dlist=-1;
  35.  
  36. struct BitMap *bm3=NULL;
  37.  
  38. struct anim_cplx *elf;
  39.  
  40. struct display_struct *display;
  41.  
  42. /*-------------------------------------------------------------------------*/
  43.  
  44. main(argc,argv)
  45. int argc;
  46. char *argv[];
  47.  
  48. {
  49.    int err,end=0;
  50.  
  51.    if (argc < 2)
  52.       {
  53.       printf("\nUSAGE: Elves [number of elves] [HIRES] [LACE]\n");
  54.       exit(01);
  55.       }
  56.    if (gs_open_libs(DOS|GRAPHICS,0))
  57.       exit(02);               /* if can't open libs, abort */
  58.    parser(argc,argv);         /* parse command line args */
  59.    if (err=setup())            /* if couldn't get set up... abort program */
  60.       {
  61.       printf("\nsetup error %d\n",err);
  62.       gs_close_libs();         /* close all libraries */
  63.       exit(03);
  64.       }
  65.    Forbid();
  66.    while (!end)
  67.       {
  68.       move_image();
  69.       end=check_close();      /* end when user hits left mouse */
  70.       }
  71.    Permit();
  72.    cleanup();                  /* close & deallocate everything */
  73.    gs_close_libs();            /* close all libraries */
  74. }
  75.  
  76. /***************************************************************************/
  77.  
  78. void parser(argc,argv)
  79. int argc;
  80. char *argv[];
  81.  
  82. {
  83.    elf_cnt=atoi(argv[1]);      /* number of complexes running around screen */
  84.    if (argc >= 3)
  85.       {
  86.       if (!(stricmp(argv[2],"HIRES")))   /* check for hires spec */
  87.          {
  88.          swidth=640;
  89.          sheight=400;
  90.          if (GfxBase->LibNode.lib_Version >= 36)
  91.             {
  92.             if (ModeNotAvailable(DBLNTSCHIRESFF_KEY))
  93.                smode=HIRES|LACE;
  94.             else
  95.                smode=DBLNTSCHIRESFF_KEY;
  96.             }
  97.          else
  98.             smode=HIRES|LACE;
  99.          }
  100.       else if (!(stricmp(argv[2],"SUPER")))   /* check for superhires */
  101.          {
  102.          if (GfxBase->LibNode.lib_Version >= 36)
  103.             {
  104.             if (ModeNotAvailable(SUPER72_MONITOR_ID | SUPERLACE_KEY))
  105.                {
  106.                swidth=640;
  107.                sheight=400;
  108.                smode=HIRES|LACE;
  109.                }
  110.             else
  111.                {
  112.                smode=SUPER72_MONITOR_ID | SUPERLACE_KEY;
  113.                swidth=800;
  114.                sheight=600;
  115.                }
  116.             }
  117.          else
  118.             {
  119.             swidth=640;
  120.             sheight=400;
  121.             smode=HIRES|LACE;
  122.             }
  123.          }
  124.       }
  125. }
  126.  
  127. /***************************************************************************/
  128.  
  129. setup()
  130.  
  131. {
  132.    int cnt,seq,depth=0;
  133.    struct anim_struct *anim;
  134.    struct blit_struct *img;
  135.  
  136.    struct anim_load_struct load =
  137.       {
  138.       "elf",                        /* name of anim file to load */
  139.       NULL,                           /* ptr to anim upon return */
  140.       NULL,                           /* ptr to attachment array specification upon return */
  141.       NULL,                           /* ptr to color map upon return */
  142.       0,                              /* # entries in the color map */
  143.       8,                              /* # bits per color map entry */
  144.       0,                              /* type (filled). 0 = anim, 1 = complex */
  145.       1,                              /* # elfs to allocate in array */
  146.       0                              /* flags */
  147.       };
  148.  
  149.    if (!(x=(int *)malloc(elf_cnt*sizeof(int))))
  150.       return(-1);
  151.    if (!(y=(int *)malloc(elf_cnt*sizeof(int))))
  152.       {
  153.       free_arrays();
  154.       return(-1);
  155.       }
  156.    if (!(speedx=(int *)malloc(elf_cnt*sizeof(int))))
  157.       {
  158.       free_arrays();
  159.       return(-1);
  160.       }
  161.    if (!(speedy=(int *)malloc(elf_cnt*sizeof(int))))
  162.       {
  163.       free_arrays();
  164.       return(-1);
  165.       }
  166.    load.array_elements=elf_cnt;      /* user specified # elves */
  167.    if (gs_load_anim(&load))
  168.       {
  169.       free_arrays();
  170.       return(-1);
  171.       }
  172.    elf=load.anim_ptr.cplx;            /* ptr to elf complex */
  173.    if (load.type != 1)               /* make sure it's an anim complex */
  174.       {
  175.       free_arrays();
  176.       if (load.type == 0)
  177.          gs_free_anim((struct anim_struct *)elf,elf_cnt);
  178.       return(-2);
  179.       }
  180.    anim = elf[0].list;               /* ptr to 1st anim in complex */
  181.    while (anim)
  182.       {
  183.       img = anim->list;               /* ptr to 1st image in anim sequence */
  184.       while (img)                     /* find max depth of anim */
  185.          {
  186.          if (img->depth > depth)
  187.             depth = img->depth;
  188.          if (img->next == img)      /* avoid infinite loop */
  189.             img=NULL;
  190.          else
  191.             img=img->next;
  192.          }
  193.       anim=anim->cplx_next;         /* next anim in complex */
  194.       }
  195.    if (!(display=gs_display(swidth,sheight,depth,smode,GSV_DOUBLE,load.cmap)))
  196.       {
  197.       free_arrays();
  198.       FreeMem(load.cmap,load.cmap_entries*sizeof(long));
  199.       gs_free_cplx(elf,elf_cnt);
  200.       return(-3);
  201.       }
  202.    FreeMem(load.cmap,load.cmap_entries*sizeof(long));
  203.    if ((dlist=gs_get_display_list()) < 0)
  204.       {
  205.       cleanup();
  206.       return(-4);
  207.       }
  208.    bm3=gs_get_bitmap(depth,swidth,sheight,0);
  209.    gs_init_anim(dlist,display->vp->bitmap1,display->vp->bitmap2,bm3);
  210.    gs_set_anim_bounds(dlist,0,0,swidth-1,sheight-1);
  211.    gs_random(0);                        /* seed random function */
  212.    for (cnt=0; cnt < elf_cnt; cnt++)
  213.       {
  214.       x[cnt] = gs_random(swidth);         /* random X,Y coords */
  215.       y[cnt] = gs_random(sheight);
  216.       while ((speedx[cnt] = gs_random(11)) < 3);
  217.       while ((speedy[cnt] = gs_random(4)) == 0);
  218.       if (cnt&1)
  219.          {
  220.          speedx[cnt]=-speedx[cnt];
  221.          speedy[cnt]=-speedy[cnt];
  222.          seq=ELF_LEFT;
  223.          }
  224.       else
  225.          seq=ELF_RIGHT;
  226.       if (bm3)                        /* if restore bitmap */
  227.          {
  228.          anim=elf[cnt].list;         /* ptr to 1st anim object in complex */
  229.          while (anim)
  230.             {
  231.             anim->flags|=ANIM_SAVE_BG;   /* use fastest display method */
  232.             if (anim->flags & ANIM_CLEAR)
  233.                anim->flags ^= ANIM_CLEAR;
  234.             if (anim->flags & ANIM_COPY)
  235.                anim->flags ^= ANIM_COPY;
  236.             anim=anim->cplx_next;   /* next anim object in complex */
  237.             }
  238.          }
  239.       if (gs_add_anim_cplx(dlist,&elf[cnt],x[cnt],y[cnt],seq,elf[cnt].list->prio))
  240.          {
  241.          cleanup();                  /* release everything */
  242.          return(-5);                  /* return failure */
  243.          }
  244.       }
  245.    gs_draw_anims(dlist);
  246.    check_bounds();
  247.    gs_next_anim_page(dlist);
  248.    gs_show_display(display,1);
  249.    gs_flip_display(display,1);
  250.    return(0);
  251. }
  252.  
  253. /***************************************************************************/
  254.  
  255. void move_image()
  256.  
  257. /* move and animate the graphic objects on the screen */
  258.  
  259. {
  260.    int cnt;
  261.  
  262.    for (cnt=0; cnt < elf_cnt; cnt++)
  263.       {
  264.       x[cnt]+=speedx[cnt];
  265.       y[cnt]+=speedy[cnt];
  266.       gs_anim_cplx(&elf[cnt],x[cnt],y[cnt]);
  267.       }
  268.    while (display->flags & GSV_FLIP);   /* while display not flipped */
  269.    gs_draw_anims(dlist);               /* draw them anim objects! */
  270.    check_bounds();                  /* keep a watch on them pesky keeblers */
  271.    gs_next_anim_page(dlist);         /* tell anim sys to use other bitmap */
  272.    gs_flip_display(display,1);      /* switch to other display, sync */
  273. }
  274.  
  275. /***************************************************************************/
  276.  
  277. void check_bounds()
  278.  
  279. {
  280.    int cnt;
  281.  
  282.    for (cnt=0; cnt < elf_cnt; cnt++)
  283.       {
  284.       if (elf[cnt].anim->flags & ANIM_BOUNDS_X1)
  285.          {
  286.          x[cnt]=elf[cnt].anim->x;
  287.          speedx[cnt]=-speedx[cnt];
  288.          gs_set_cplx_seq(&elf[cnt],ELF_RIGHT,x[cnt],y[cnt]);
  289.          }
  290.       else if (elf[cnt].anim->flags & ANIM_BOUNDS_X2)
  291.          {
  292.          x[cnt]=elf[cnt].anim->x;
  293.          speedx[cnt]=-speedx[cnt];
  294.          gs_set_cplx_seq(&elf[cnt],ELF_LEFT,x[cnt],y[cnt]);
  295.          }
  296.       if (elf[cnt].anim->flags & (ANIM_BOUNDS_Y1|ANIM_BOUNDS_Y2))
  297.          {
  298.          y[cnt]=elf[cnt].anim->y;
  299.          speedy[cnt]=-speedy[cnt];
  300.          }
  301.       }
  302. }
  303.  
  304. /***************************************************************************/
  305.  
  306. int check_close()
  307.  
  308. /* check for user input */
  309.  
  310. {
  311.    if (gs_joystick(0) & (JOY_BUTTON1|JOY_BUTTON2))   /* IF (mouse button pressed) */
  312.       return(1);                     /* ..time to wrap up */
  313.    return(0);                        /* ELSE (keep going) */
  314. }
  315.  
  316. /***************************************************************************/
  317.  
  318. void cleanup()
  319.  
  320. /* release all resources and memory */
  321.  
  322. {
  323.    free_arrays();
  324.    gs_free_cplx(elf,elf_cnt);
  325.    if (dlist >= 0)
  326.       gs_free_display_list(dlist);
  327.    gs_remove_display(display);
  328. }
  329.  
  330. /***************************************************************************/
  331.  
  332. void free_arrays()
  333.  
  334. {
  335.    if (x)
  336.       free(x);                     /* free up control arrays */
  337.    if (y)
  338.       free(y);
  339.    if (speedx)
  340.       free(speedx);
  341.    if (speedy)
  342.       free(speedy);
  343.    if (bm3)
  344.       gs_free_bitmap(bm3);
  345. }
  346.